import fs from 'fs';
import path from 'path';
import { spawnSync } from 'child_process';
import express from 'express';
import cron from 'node-cron';

// 配置部分
const config = {
    projectPath: 'C:\\Users\\li\\Desktop\\shuhai\\shuhai',
    giteeRepo: 'https://gitee.com/liyucheng369/publishing-office-assistant.git',
    branch: 'master',
    logFile: 'D:\\Ai_logs\\shuhai.json',
    port: 3009,
    cronSchedule: '*/5 * * * *', // 每5分钟执行一次
    gitUserName: 'liyucheng369',
    gitUserEmail: '823976085@qq.com'
};

// 修改方法集合 - 针对微信小程序的修改方法
const modificationMethods = [
    (functionCode, functionName) => {
        const newParam = `param${Math.floor(Math.random() * 100)}`;
        return functionCode.replace(/(function\s+\w+\s*\([^)]*)/, `$1, ${newParam}`);
    },
    (functionCode, functionName) => {
        const lines = functionCode.split('\n');
        const insertIndex = Math.max(1, Math.floor(Math.random() * lines.length));
        lines.splice(insertIndex, 0, `    console.log("微信小程序函数 ${functionName} 执行时间: ", new Date());`);
        return lines.join('\n');
    }
];

// 日志系统
class Logger {
    constructor(logFile) {
        this.logFile = logFile;
        this.ensureLogFile();
    }

    ensureLogFile() {
        try {
            const dir = path.dirname(this.logFile);
            if (!fs.existsSync(dir)) {
                fs.mkdirSync(dir, { recursive: true });
            }
            if (!fs.existsSync(this.logFile)) {
                fs.writeFileSync(this.logFile, JSON.stringify([], null, 2));
            }
        } catch (error) {
            console.error('创建日志文件失败:', error.message);
        }
    }

    log(operation, file, functionName, success = true, message = '') {
        const entry = {
            timestamp: new Date().toISOString(),
            operation,
            file,
            functionName,
            success,
            message
        };

        try {
            let logs = [];
            if (fs.existsSync(this.logFile)) {
                const content = fs.readFileSync(this.logFile, 'utf8');
                if (content.trim()) {
                    logs = JSON.parse(content);
                }
            }
            logs.push(entry);
            fs.writeFileSync(this.logFile, JSON.stringify(logs, null, 2));
            console.log(`[${new Date().toLocaleString()}] ${operation} ${success ? '成功' : '失败'}: ${file} -> ${functionName} ${message}`);
        } catch (error) {
            console.error('写入日志失败:', error.message);
        }
    }

    getLogs(limit = 50) {
        try {
            if (fs.existsSync(this.logFile)) {
                const logs = JSON.parse(fs.readFileSync(this.logFile, 'utf8'));
            }
        } catch (error) {
            console.error('读取日志失败:', error.message);
        }
        return [];
    }
}

// 主功能类 - 处理微信小程序文件
class WechatMiniProgramModifier {
    constructor(config) {
        this.config = config;
        this.logger = new Logger(config.logFile);
        this.lastRun = null;
        this.isRunning = false;
        this.gitAvailable = this.checkGitAvailability();

        // 微信小程序常用函数名前缀
        this.functionPrefixes = [
            'on', 'handle', 'get', 'set', 'load', 'save', 'create', 'update', 'delete',
            'show', 'hide', 'open', 'close', 'start', 'stop', 'check', 'validate',
            'upload', 'download', 'choose', 'preview', 'request', 'login', 'pay'
        ];

        // 微信小程序常用函数名后缀
        this.functionSuffixes = [
            'Data', 'List', 'Info', 'Detail', 'User', 'Form', 'Data', 'Success', 'Fail',
            'Complete', 'Change', 'Click', 'Tap', 'Load', 'Ready', 'Show', 'Hide',
            'PullDown', 'ReachBottom', 'Share', 'Auth', 'Login', 'Payment', 'Image'
        ];

        // 微信小程序特定生命周期函数
        this.wechatLifecycleFunctions = [
            'onLoad', 'onShow', 'onReady', 'onHide', 'onUnload', 'onPullDownRefresh',
            'onReachBottom', 'onShareAppMessage', 'onShareTimeline', 'onAddToFavorites',
            'onPageScroll', 'onResize', 'onTabItemTap'
        ];

        // 微信小程序API函数
        this.wechatApiFunctions = [
            'wx.request', 'wx.uploadFile', 'wx.downloadFile', 'wx.login', 'wx.getUserInfo',
            'wx.getStorage', 'wx.setStorage', 'wx.getSystemInfo', 'wx.showToast',
            'wx.showModal', 'wx.showLoading', 'wx.hideLoading', 'wx.navigateTo',
            'wx.redirectTo', 'wx.switchTab', 'wx.navigateBack', 'wx.chooseImage',
            'wx.previewImage', 'wx.getLocation', 'wx.chooseLocation', 'wx.openLocation',
            'wx.getNetworkType', 'wx.onNetworkStatusChange', 'wx.scanCode', 'wx.vibrate'
        ];

        // 中文提交信息选项
        this.commitTypes = ['小程序运维', '功能开发', '页面优化', '接口更新', 'BUG修复', '测试', '重构'];
        this.commitActions = ['添加了', '优化了', '改进了', '完成了', '实现了', '创建了'];

        console.log('微信小程序代码修改器初始化完成');
        console.log('Git可用:', this.gitAvailable);
        console.log('项目路径:', this.config.projectPath);
    }

    // 检查Git是否可用
    checkGitAvailability() {
        try {
            const result = spawnSync('git', ['--version'], {
                windowsHide: true,
                encoding: 'utf8'
            });
            return result.status === 0;
        } catch (error) {
            console.log('Git不可用，将仅进行本地文件修改');
            return false;
        }
    }

    // 执行 Git 命令
    execGitCommand(args, options = {}) {
        if (!this.gitAvailable) {
            throw new Error('Git不可用');
        }

        try {
            const result = spawnSync('git', args, {
                cwd: this.config.projectPath,
                windowsHide: true,
                encoding: 'utf8',
                ...options
            });

            if (result.status !== 0) {
                throw new Error(result.stderr || `Git命令执行失败: git ${args.join(' ')}`);
            }

            return result.stdout;
        } catch (error) {
            throw new Error(`Git命令执行错误: ${error.message}`);
        }
    }

    // 初始化 Git 仓库
    async initializeGitRepository() {
        if (!this.gitAvailable) {
            console.log('Git不可用，跳过Git初始化');
            return false;
        }

        try {
            // 检查是否是Git仓库
            try {
                this.execGitCommand(['status']);
                console.log('Git仓库已存在');
                return true;
            } catch {
                console.log('初始化新的Git仓库...');
                this.execGitCommand(['init']);
                
                // 设置用户信息
                try {
                    this.execGitCommand(['config', 'user.name', this.config.gitUserName]);
                    this.execGitCommand(['config', 'user.email', this.config.gitUserEmail]);
                } catch (configError) {
                    console.log('Git配置设置失败:', configError.message);
                }

                // 添加远程仓库
                try {
                    this.execGitCommand(['remote', 'add', 'origin', this.config.giteeRepo]);
                } catch (remoteError) {
                    console.log('添加远程仓库失败:', remoteError.message);
                }

                return true;
            }
        } catch (error) {
            console.error('Git初始化失败:', error.message);
            return false;
        }
    }

    // 查找所有微信小程序文件
    findAllWechatFiles(dirPath, arrayOfFiles = []) {
        try {
            if (!fs.existsSync(dirPath)) {
                console.log(`目录不存在: ${dirPath}`);
                return arrayOfFiles;
            }

            const files = fs.readdirSync(dirPath);
            
            for (const file of files) {
                const fullPath = path.join(dirPath, file);
                try {
                    const stat = fs.statSync(fullPath);
                    if (stat.isDirectory()) {
                        // 排除不需要的目录
                        if (!file.startsWith('.') && 
                            !file.includes('node_modules') && 
                            !file.includes('target') && 
                            !file.includes('build') &&
                            !file.includes('.git') &&
                            !file.includes('lib')) {
                            this.findAllWechatFiles(fullPath, arrayOfFiles);
                        }
                    } else if (file.toLowerCase().endsWith('.js') || 
                              file.toLowerCase().endsWith('.wxml') ||
                              file.toLowerCase().endsWith('.wxss') ||
                              file.toLowerCase().endsWith('.json')) {
                        arrayOfFiles.push(fullPath);
                    }
                } catch (error) {
                    console.log(`跳过 ${fullPath}: ${error.message}`);
                }
            }
        } catch (error) {
            console.log(`读取目录错误 ${dirPath}: ${error.message}`);
        }
        return arrayOfFiles;
    }

    // 从文件中提取函数
    extractFunctions(code, fileExtension) {
        const functions = [];
        if (!code) return functions;

        try {
            if (fileExtension === '.js') {
                // 提取JavaScript函数
                const functionRegex = /(function\s+(\w+)|(const|let|var)\s+(\w+)\s*=\s*(async\s*)?\s*\([^)]*\)\s*=>|(const|let|var)\s+(\w+)\s*=\s*function|(\w+)\s*\([^)]*\)\s*\{)/g;
                let match;

                while ((match = functionRegex.exec(code)) !== null) {
                    let functionName = match[2] || match[4] || match[7] || match[8];
                    if (!functionName || functionName === 'function') continue;

                    const startPos = match.index;
                    let braceCount = 0;
                    let endPos = startPos;
                    let foundStart = false;

                    for (let i = startPos; i < Math.min(startPos + 1000, code.length); i++) {
                        if (code[i] === '{') {
                            braceCount++;
                            foundStart = true;
                        }
                        if (code[i] === '}') braceCount--;
                        if (foundStart && braceCount === 0) {
                            endPos = i;
                            break;
                        }
                    }

                    if (endPos > startPos) {
                        functions.push({
                            name: functionName,
                            code: code.substring(startPos, endPos + 1),
                            type: 'javascript',
                            fileType: 'js'
                        });
                    }
                }

                // 提取Page和Component中的方法
                const pageMethodRegex = /(onLoad|onShow|onReady|onHide|onUnload|onPullDownRefresh|onReachBottom|onShareAppMessage|onPageScroll|onTabItemTap|onResize|onAddToFavorites)\s*:\s*function[^}]*\}/g;
                let pageMatch;
                
                while ((pageMatch = pageMethodRegex.exec(code)) !== null) {
                    const methodNameMatch = pageMatch[0].match(/(\w+)\s*:\s*function/);
                    if (methodNameMatch && methodNameMatch[1]) {
                        functions.push({
                            name: methodNameMatch[1],
                            code: pageMatch[0],
                            type: 'pageMethod',
                            fileType: 'js'
                        });
                    }
                }
            }
        } catch (error) {
            console.log('提取函数错误:', error.message);
        }
        
        return functions;
    }

    // 生成微信小程序风格的函数名
    generateWechatFunctionName() {
        // 30%几率使用微信特定生命周期函数
        if (Math.random() < 0.3 && this.wechatLifecycleFunctions.length > 0) {
            return this.wechatLifecycleFunctions[
                Math.floor(Math.random() * this.wechatLifecycleFunctions.length)
            ];
        }

        // 70%几率生成组合函数名
        const prefix = this.functionPrefixes[Math.floor(Math.random() * this.functionPrefixes.length)];
        const suffix = this.functionSuffixes[Math.floor(Math.random() * this.functionSuffixes.length)];
        return prefix + suffix;
    }

    // 生成微信小程序函数模板
    generateWechatFunctionTemplate(functionName) {
        // 如果是微信生命周期函数
        if (this.wechatLifecycleFunctions.includes(functionName)) {
            const templates = {
                'onLoad': `${functionName}: function(options) {\n    // 页面加载时执行\n    console.log('页面加载，参数:', options);\n    this.loadData();\n},`,
                'onShow': `${functionName}: function() {\n    // 页面显示时执行\n    console.log('页面显示');\n},`,
                'onReady': `${functionName}: function() {\n    // 页面初次渲染完成时执行\n    console.log('页面准备就绪');\n},`,
                'onHide': `${functionName}: function() {\n    // 页面隐藏时执行\n    console.log('页面隐藏');\n},`,
                'onUnload': `${functionName}: function() {\n    // 页面卸载时执行\n    console.log('页面卸载');\n},`,
                'onPullDownRefresh': `${functionName}: function() {\n    // 下拉刷新时执行\n    console.log('下拉刷新');\n    wx.stopPullDownRefresh();\n},`,
                'onReachBottom': `${functionName}: function() {\n    // 页面上拉触底时执行\n    console.log('上拉触底');\n    this.loadMoreData();\n},`,
                'onShareAppMessage': `${functionName}: function() {\n    // 用户点击右上角分享时执行\n    return {\n        title: '分享标题',\n        path: '/pages/index/index'\n    };\n},`
            };
            return templates[functionName] || `${functionName}: function() {\n    // ${functionName} 生命周期函数\n    console.log('${functionName} executed');\n},`;
        }

        // 普通函数模板
        const templates = [
            `function ${functionName}() {\n    // 微信小程序函数\n    console.log('${functionName} executed at', new Date());\n    return true;\n}`,
            
            `function ${functionName}(param) {\n    // 处理业务逻辑\n    if (!param) {\n        wx.showToast({\n            title: '参数不能为空',\n            icon: 'none'\n        });\n        return false;\n    }\n    return this.processData(param);\n}`,
            
            `function ${functionName}() {\n    // 网络请求函数\n    return new Promise((resolve, reject) => {\n        wx.request({\n            url: 'https://api.example.com/data',\n            success: (res) => {\n                resolve(res.data);\n            },\n            fail: (err) => {\n                reject(err);\n            }\n        });\n    });\n}`,
            
            `function ${functionName}(e) {\n    // 事件处理函数\n    const { value } = e.detail;\n    this.setData({\n        inputValue: value\n    });\n    this.validateInput(value);\n}`,
            
            `async function ${functionName}() {\n    // 异步处理函数\n    try {\n        wx.showLoading({\n            title: '加载中...'\n        });\n        const result = await this.apiRequest();\n        this.setData({ data: result });\n        wx.hideLoading();\n    } catch (error) {\n        wx.hideLoading();\n        wx.showToast({\n            title: '加载失败',\n            icon: 'none'\n        });\n    }\n}`
        ];
        
        return templates[Math.floor(Math.random() * templates.length)];
    }

    // 生成中文提交信息
    generateChineseCommitMessage(functionName) {
        const randomType = this.commitTypes[Math.floor(Math.random() * this.commitTypes.length)];
        const randomAction = this.commitActions[Math.floor(Math.random() * this.commitActions.length)];
        
        // 如果是微信生命周期函数，生成特定的提交信息
        if (this.wechatLifecycleFunctions.includes(functionName)) {
            return `${randomType}: ${randomAction} ${functionName} 生命周期函数`;
        }
        
        return `${randomType}: ${randomAction} 微信小程序函数 ${functionName}`;
    }

    // 在文件中添加新函数
    addFunctionToFile(fileContent, newFunctionCode, fileExtension) {
        if (fileExtension === '.js') {
            // 在JS文件中添加
            // 查找Page或Component定义的结束位置
            const pageEndIndex = fileContent.lastIndexOf('})');
            if (pageEndIndex !== -1) {
                // 在Page或Component定义之前插入
                return fileContent.substring(0, pageEndIndex) + 
                       '\n\n  // 自动添加的微信小程序函数\n  ' + 
                       newFunctionCode + '\n\n' +
                       fileContent.substring(pageEndIndex);
            } else {
                // 在文件末尾添加
                return fileContent + '\n\n// 自动添加的微信小程序函数\n' + newFunctionCode + '\n';
            }
        }
        return fileContent;
    }

    // 执行修改
    async modifyAndCommit() {
        if (this.isRunning) {
            console.log('已有任务正在运行，跳过本次执行');
            return;
        }
        
        this.isRunning = true;
        this.lastRun = new Date();

        try {
            console.log('开始微信小程序代码修改过程...');
            console.log('当前时间:', new Date().toLocaleString());

            // 检查项目路径是否存在
            if (!fs.existsSync(this.config.projectPath)) {
                throw new Error(`项目路径不存在: ${this.config.projectPath}`);
            }

            // 查找微信小程序文件
            const wechatFiles = this.findAllWechatFiles(this.config.projectPath);
            if (wechatFiles.length === 0) {
                throw new Error('未找到微信小程序文件');
            }

            console.log(`找到 ${wechatFiles.length} 个微信小程序文件`);

            // 优先选择JS文件
            const jsFiles = wechatFiles.filter(file => file.toLowerCase().endsWith('.js'));
            const targetFiles = jsFiles.length > 0 ? jsFiles : wechatFiles;
            
            // 随机选择一个文件
            const randomFile = targetFiles[Math.floor(Math.random() * targetFiles.length)];
            const fileExtension = path.extname(randomFile).toLowerCase();
            const fileName = path.basename(randomFile);
            console.log(`选择文件: ${fileName} (${fileExtension})`);

            // 读取文件内容
            const fileContent = fs.readFileSync(randomFile, 'utf8');
            
            // 提取现有函数
            const functions = this.extractFunctions(fileContent, fileExtension);
            console.log(`提取到 ${functions.length} 个函数`);

            // 生成新函数名
            const newFunctionName = this.generateWechatFunctionName();
            const newFunctionCode = this.generateWechatFunctionTemplate(newFunctionName);

            console.log(`生成新函数: ${newFunctionName}`);

            // 在文件中添加新函数
            const newFileContent = this.addFunctionToFile(fileContent, newFunctionCode, fileExtension);
            
            // 备份原文件
            const backupPath = randomFile + '.bak';
            fs.writeFileSync(backupPath, fileContent, 'utf8');
            
            // 写入修改后的文件
            fs.writeFileSync(randomFile, newFileContent, 'utf8');

            console.log(`成功添加函数到文件: ${fileName}`);

            // 如果有Git则进行提交
            if (this.gitAvailable) {
                try {
                    await this.initializeGitRepository();
                    const commitMessage = this.generateChineseCommitMessage(newFunctionName);
                    
                    this.execGitCommand(['add', '.']);
                    this.execGitCommand(['commit', '-m', commitMessage]);
                    
                    console.log('Git提交成功:', commitMessage);
                    
                    // 尝试推送到远程
                    try {
                        this.execGitCommand(['push', '-u', 'origin', this.config.branch]);
                        console.log('推送到远程仓库成功');
                    } catch (pushError) {
                        console.log('推送失败，但提交已成功:', pushError.message);
                    }
                    
                    this.logger.log('微信小程序修改', fileName, newFunctionName, true, `添加了微信小程序函数并提交到Git`);
                    
                } catch (gitError) {
                    console.log('Git操作失败，但文件修改已完成:', gitError.message);
                    this.logger.log('微信小程序修改', fileName, newFunctionName, true, `添加了微信小程序函数（Git操作失败）`);
                }
            } else {
                this.logger.log('微信小程序修改', fileName, newFunctionName, true, `添加了微信小程序函数（无Git环境）`);
            }

            console.log('微信小程序代码修改过程完成');

        } catch (error) {
            console.error('执行过程中发生错误:', error.message);
            this.logger.log('执行', '系统', 'N/A', false, error.message);
        } finally {
            this.isRunning = false;
        }
    }

    // 启动定时任务
    startScheduler() {
        console.log('启动微信小程序代码修改调度器...');
        console.log('定时计划:', this.config.cronSchedule);
        
        // 设置定时任务
        cron.schedule(this.config.cronSchedule, () => {
            console.log('\n--- 定时任务触发 ---');
            this.modifyAndCommit();
        });
        
        // 启动监控服务器
        this.startMonitorServer();
        
        // 立即执行一次
        console.log('立即执行第一次修改...');
        setTimeout(() => this.modifyAndCommit(), 2000);
    }

    // 启动监控服务器
    startMonitorServer() {
        const app = express();
        
        app.get('/', (req, res) => {
            const status = {
                running: this.isRunning,
                lastRun: this.lastRun ? this.lastRun.toLocaleString() : '从未运行',
                gitAvailable: this.gitAvailable,
                projectPath: this.config.projectPath,
                logs: this.logger.getLogs(10)
            };
            
            res.send(`
            <html>
                <head>
                    <title>微信小程序代码修改器监控</title>
                    <style>
                        body { font-family: Arial, sans-serif; margin: 20px; }
                        .status { background: #f5f5f5; padding: 15px; border-radius: 5px; }
                        .log { margin-top: 20px; }
                        .success { color: green; }
                        .error { color: red; }
                    </style>
                </head>
                <body>
                    <h1>微信小程序代码修改器监控</h1>
                    <div class="status">
                        <p><strong>状态:</strong> ${status.running ? '运行中' : '空闲'}</p>
                        <p><strong>上次运行:</strong> ${status.lastRun}</p>
                        <p><strong>Git状态:</strong> ${status.gitAvailable ? '可用' : '不可用'}</p>
                        <p><strong>项目路径:</strong> ${status.projectPath}</p>
                        <p><strong>支持函数:</strong> ${this.wechatLifecycleFunctions.length} 个生命周期函数</p>
                    </div>
                    <div class="log">
                        <h3>最近日志</h3>
                        <ul>
                            ${status.logs.map(log => `
                                <li class="${log.success ? 'success' : 'error'}">
                                    [${new Date(log.timestamp).toLocaleString()}] 
                                    ${log.operation} - ${log.file} - ${log.functionName}
                                    ${log.message ? `(${log.message})` : ''}
                                </li>
                            `).join('')}
                        </ul>
                    </div>
                </body>
            </html>
            `);
        });
        
        app.listen(this.config.port, () => {
            console.log(`监控服务器运行在 http://localhost:${this.config.port}`);
        });
    }
}

// 主程序
try {
    console.log('正在启动微信小程序代码修改器...');
    const modifier = new WechatMiniProgramModifier(config);
    modifier.startScheduler();
} catch (error) {
    console.error('程序启动失败:', error.message);
    process.exit(1);
}